package cn.ly.design.action.agent;

/**
 * 理解不深刻
 * 
 * 中介者模式也是用来降低类类之间的耦合的，因为如果类类之间有依赖关系的话，不利于功能的拓展和维护，因为只要修改一个对象，
 * 其它关联的对象都得进行修改。如果使用中介者模式，只需关心和Mediator类的关系，具体类类之间的关系及调度交给Mediator就行
 * @author liuyu
 *
 */
public class MediatorTest {

}

abstract class Mediator {
	// 定义同事类
	protected ConcreteColleague1 c1;
	protected ConcreteColleague2 c2;

	// 通过getter/setter方法把同事类注入进来
	public ConcreteColleague1 getC1() {
		return c1;
	}

	public void setC1(ConcreteColleague1 c1) {
		this.c1 = c1;
	}

	public ConcreteColleague2 getC2() {
		return c2;
	}

	public void setC2(ConcreteColleague2 c2) {
		this.c2 = c2;
	}

	// 中介者模式的业务逻辑
	public abstract void doSomething1();

	public abstract void doSomething2();
}

class ConcreteMediator extends Mediator {
	@Override
	public void doSomething1() {
		// 调用同事类的方法，只要是public方法都可以调用
		super.c1.selfMethod1();
		super.c2.selfMethod2();
	}

	public void doSomething2() {
		super.c1.selfMethod1();
		super.c2.selfMethod2();
	}
}

abstract class Colleague {
	protected Mediator mediator;

	public Colleague(Mediator _mediator) {
		this.mediator = _mediator;
	}
}

class ConcreteColleague1 extends Colleague {
	// 通过构造函数传递中介者
	public ConcreteColleague1(Mediator _mediator) {
		super(_mediator);
	}

	// 自有方法 self-method
	public void selfMethod1() {
		// 处理自己的业务逻辑
	}

	// 依赖方法 dep-method
	public void depMethod1() {
		// 处理自己的业务逻辑
		// 自己不能处理的业务逻辑，委托给中介者处理
		super.mediator.doSomething1();
	}
}

class ConcreteColleague2 extends Colleague {
	// 通过构造函数传递中介者
	public ConcreteColleague2(Mediator _mediator){
		super(_mediator);
	}

	// 自有方法 self-method
	public void selfMethod2() {
		// 处理自己的业务逻辑
	}

	// 依赖方法 dep-method
	public void depMethod2() {
		// 处理自己的业务逻辑
		// 自己不能处理的业务逻辑，委托给中介者处理
		super.mediator.doSomething2();
	}
}
